/*
 * Copyright (c) 2014 Nordic Semiconductor. All Rights Reserved.
 *
 * The information contained herein is confidential property of Nordic Semiconductor. The use,
 * copying, transfer or disclosure of such information is prohibited except by express written
 * agreement with Nordic Semiconductor.
 *
 */

/**
 * @brief BLE LED Button Service central and client application main file.
 *
 * This example can be a central for up to 8 peripherals.
 * The peripheral is called ble_app_blinky and can be found in the ble_peripheral
 * folder.
 */

#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "nordic_common.h"
#include "softdevice_handler.h"
#include "app_timer.h"
#include "app_trace.h"
#include "boards.h"
#include "bsp.h"
#include "bsp_btn_ble.h"
#include "ble.h"
#include "app_uart.h"
#include "ble_advdata.h"
#include "ble_advertising.h"
#include "ble_conn_params.h"
#include "ble_db_discovery.h"
#include "ble_lbs_c.h"
#include "ble_conn_state.h"
#include "nrf_log.h"
#include "pstorage.h"

#include "ble_types.h"
#include "nrf_gpio.h"

#include "ble_srv_common.h"
#include "ble_gattc.h"

#include "sdk_common.h"
#include "ble_lbs_c.h"
#include "nrf_delay.h"
#include "nrf_drv_wdt.h"
#include "ble_hci.h"
#include "data_to_res.h"
#include "my_ble_connect_cb.h"
#include "beep.h"

extern int8_t RSSI;
void uart_exit(void);
void simple_uart_config(  uint8_t rts_pin_number,
                          uint8_t txd_pin_number,
                          uint8_t cts_pin_number,
                          uint8_t rxd_pin_number,
                          bool    hwfc);

#define CENTRAL_LINK_COUNT        1                                          /**< Number of central links used by the application. When changing this number remember to adjust the RAM settings*/
#define PERIPHERAL_LINK_COUNT     0                                          /**< Number of peripheral links used by the application. When changing this number remember to adjust the RAM settings*/
#define TOTAL_LINK_COUNT          CENTRAL_LINK_COUNT + PERIPHERAL_LINK_COUNT /**< Total number of links used by the application. */
#define APPL_LOG                  app_trace_log                              /**< Macro used to log debug information over UART. */

#define CENTRAL_SCANNING_LED      BSP_LED_0_MASK
#define CENTRAL_CONNECTED_LED     BSP_LED_1_MASK

#define BSP_APP_TIMERS_NUMBER     2
#define APP_TIMER_PRESCALER       0                                          /**< Value of the RTC1 PRESCALER register. */
#define APP_TIMER_MAX_TIMERS      (2+BSP_APP_TIMERS_NUMBER)                  /**< Maximum number of timers used by the application. */
#define APP_TIMER_OP_QUEUE_SIZE   5                                          /**< Size of timer operation queues. */

#define SCAN_INTERVAL             0x00A0                                     /**< Determines scan interval in units of 0.625 millisecond. */
#define SCAN_WINDOW               0x0050                                     /**< Determines scan window in units of 0.625 millisecond. */
#define SCAN_TIMEOUT              0x0000                                     /**< Timout when scanning. 0x0000 disables timeout. */
#define SCAN_REQUEST              0                                          /**< Active scannin is not set. */
#define SCAN_WHITELIST_ONLY       0                                          /**< We will not ignore unknown devices. */
                                                                             
#define MIN_CONNECTION_INTERVAL   MSEC_TO_UNITS(100, UNIT_1_25_MS)           /**< Determines minimum connection interval in milliseconds. */
#define MAX_CONNECTION_INTERVAL   MSEC_TO_UNITS(100, UNIT_1_25_MS)           /**< Determines maximum connection interval in milliseconds. */
#define SLAVE_LATENCY             0                                          /**< Determines slave latency in terms of connection events. */
#define SUPERVISION_TIMEOUT       MSEC_TO_UNITS(500, UNIT_10_MS)            /**< Determines supervision time-out in units of 10 milliseconds. */

#define UUID16_SIZE               2                                          /**< Size of a UUID, in bytes. */

#define LEDBUTTON_LED             BSP_LED_2_MASK                             /**< LED to indicate a change of state of the the Button characteristic on the peer. */

#define LEDBUTTON_BUTTON_PIN      BSP_BUTTON_0                               /**< Button that will write to the LED characteristic of the peer */
#define BUTTON_DETECTION_DELAY    APP_TIMER_TICKS(10, APP_TIMER_PRESCALER)   /**< Delay from a GPIOTE event until a button is reported as pushed (in number of timer ticks). */

static const char m_target_periph_name[] = "Nordic_Blinky";                  /**< Name of the device we try to connect to. This name is searched for in the scan report data*/
extern uint8_t peer_mac[20][6];

//#define TARGET_SRV_UUID           0x1811 
//#define TARGET_CCCD_handle        0x0010

#define TARGET_SRV_UUID           0xFFF0
#define TARGET_CCCD_handle        0x000F
#define TARGET_SRV_UUID2          0xFFF1
#define TARGET_CCCD_handle2       0x17

/** @brief Scan parameters requested for scanning and connection. */
static const ble_gap_scan_params_t m_scan_param =
{
    SCAN_REQUEST,
    SCAN_WHITELIST_ONLY,
    NULL,
    (uint16_t)SCAN_INTERVAL,
    (uint16_t)SCAN_WINDOW,
    SCAN_TIMEOUT
};

/**@brief Connection parameters requested for connection. */
static const ble_gap_conn_params_t m_connection_param =
{
    (uint16_t)MIN_CONNECTION_INTERVAL,
    (uint16_t)MAX_CONNECTION_INTERVAL,
    (uint16_t)SLAVE_LATENCY,
    (uint16_t)SUPERVISION_TIMEOUT
};

static ble_lbs_c_t        m_ble_lbs_c[TOTAL_LINK_COUNT];           /**< Main structures used by the LED Button client module. */
static uint8_t            m_ble_lbs_c_count;                       /**< Keeps track of how many instances of LED Button client module have been initialized. >*/
static ble_db_discovery_t m_ble_db_discovery[TOTAL_LINK_COUNT];    /**< list of DB structures used by the database discovery module. */

/**@brief Function to handle asserts in the SoftDevice.
 *
 * @details This function will be called in case of an assert in the SoftDevice.
 *
 * @warning This handler is an example only and does not fit a final product. You need to analyze
 *          how your product is supposed to react in case of Assert.
 * @warning On assert from the SoftDevice, the system can only recover on reset.
 *
 * @param[in] line_num     Line number of the failing ASSERT call.
 * @param[in] p_file_name  File name of the failing ASSERT call.
 */
void assert_nrf_callback(uint16_t line_num, const uint8_t * p_file_name)
{
    app_error_handler(0xDEADBEEF, line_num, p_file_name);
}


/**@brief Function for the LEDs initialization.
 *
 * @details Initializes all LEDs used by the application.
 */
static void leds_init(void)
{
    LEDS_CONFIGURE(CENTRAL_SCANNING_LED | CENTRAL_CONNECTED_LED | LEDBUTTON_LED);
    LEDS_OFF(CENTRAL_SCANNING_LED | CENTRAL_CONNECTED_LED | LEDBUTTON_LED);
}


/**
 * @brief Parses advertisement data, providing length and location of the field in case
 *        matching data is found.
 *
 * @param[in]  type       Type of data to be looked for in advertisement data.
 * @param[in]  p_advdata  Advertisement report length and pointer to report.
 * @param[out] p_typedata If data type requested is found in the data report, type data length and
 *                        pointer to data will be populated here.
 *
 * @retval NRF_SUCCESS if the data type is found in the report.
 * @retval NRF_ERROR_NOT_FOUND if the data type could not be found.
 */
static uint32_t adv_report_parse(uint8_t type, uint8_array_t * p_advdata, uint8_array_t * p_typedata)
{
    uint32_t  index = 0;
    uint8_t * p_data;

    p_data = p_advdata->p_data;

    while (index < p_advdata->size)
    {
        uint8_t field_length = p_data[index];
        uint8_t field_type   = p_data[index + 1];

        if (field_type == type)
        {
            p_typedata->p_data = &p_data[index + 2];
            p_typedata->size   = field_length - 1;
            return NRF_SUCCESS;
        }
        index += field_length + 1;
    }
    return NRF_ERROR_NOT_FOUND;
}


/**@brief Function to start scanning.
 */
uint32_t scan_error=0;
void scan_start(void)
{
    ret_code_t err_code;

    err_code = sd_ble_gap_scan_stop();
    // It is okay to ignore this error since we are stopping the scan anyway.
    if (err_code != NRF_ERROR_INVALID_STATE)
    {
        APP_ERROR_CHECK(err_code);
    }

//    //NRF_LOG_PRINTF("[APP]: start scanning for device name %s\r\n", m_target_periph_name);
//    err_code = sd_ble_gap_scan_start(&m_scan_param);
//    APP_ERROR_CHECK(err_code);
		
    //NRF_LOG_PRINTF("[APP]: start scanning for device name %s\r\n", m_target_periph_name);
    err_code = sd_ble_gap_scan_start(&m_scan_param);
    scan_error = err_code;
    if (err_code != NRF_ERROR_INVALID_STATE)
    {
        APP_ERROR_CHECK(err_code);
    }
		
//		sd_ble_gap_scan_start(&m_scan_param);

}


/**@brief Handles events coming from the LED Button central module.
 *
 * @param[in] p_lbs_c     The instance of LBS_C that triggered the event.
 * @param[in] p_lbs_c_evt The LBS_C event.
 */
static void lbs_c_evt_handler(ble_lbs_c_t * p_lbs_c, ble_lbs_c_evt_t * p_lbs_c_evt)
{
    const uint16_t conn_handle = p_lbs_c_evt->conn_handle;
    switch (p_lbs_c_evt->evt_type)
    {
        case BLE_LBS_C_EVT_DISCOVERY_COMPLETE:
        {
            ret_code_t err_code;

           // NRF_LOG_PRINTF("[APP]: LED Button service discovered on conn_handle 0x%x\r\n", 
           //                 conn_handle);
            
            err_code = app_button_enable();
            APP_ERROR_CHECK(err_code);

            // LED Button service discovered. Enable notification of Button.
            err_code = ble_lbs_c_button_notif_enable(p_lbs_c);
            APP_ERROR_CHECK(err_code);
        } break; // BLE_LBS_C_EVT_DISCOVERY_COMPLETE

        case BLE_LBS_C_EVT_BUTTON_NOTIFICATION:
        {
//            NRF_LOG_PRINTF("[APP]: Link 0x%x, Button state changed on peer to 0x%x\r\n", 
//                           conn_handle,
//            p_lbs_c_evt->params.button.button_state);
            if (p_lbs_c_evt->params.button.button_state)
            {
                LEDS_ON(LEDBUTTON_LED);
            }
            else
            {
                LEDS_OFF(LEDBUTTON_LED);
            }
        } break; // BLE_LBS_C_EVT_BUTTON_NOTIFICATION

        default:
            // No implementation needed.
            break;
    }
}

/**@brief Function for handling the advertising report BLE event.
 *
 * @param[in] p_ble_evt  Bluetooth stack event.
 */
uint32_t central_link_cnt2;
uint32_t report_error;
uint32_t my_connect_cnt=0;
int8_t rssi_test;
bool do_connect = false;
uint8_t cm_peermac_flag=0;
ble_gap_addr_t test_peer_mac;
uint32_t mcccd_handle=0;
uint16_t m_uuid = 0;
static void on_adv_report(const ble_evt_t * const p_ble_evt)
{
    uint32_t      err_code;
    uint8_array_t adv_data;
    uint8_array_t dev_srv_UUID;
    uint8_array_t dev_name;
    static uint8_t flag=0;
    // For readibility.
    const ble_gap_evt_t * const p_gap_evt    = &p_ble_evt->evt.gap_evt;
    const ble_gap_addr_t  * const peer_addr  = &p_gap_evt->params.adv_report.peer_addr;
    
    test_peer_mac = *peer_addr;
    // Initialize advertisement report for parsing
    adv_data.p_data = (uint8_t *)p_gap_evt->params.adv_report.data;
    adv_data.size   = p_gap_evt->params.adv_report.dlen;

    //search for advertising names
    bool found_name = false;
//    err_code = adv_report_parse(BLE_GAP_AD_TYPE_16BIT_SERVICE_UUID_MORE_AVAILABLE,
//                                &adv_data,
//                                &dev_srv_UUID);
	
    err_code = adv_report_parse(0x02,
                                &adv_data,
                                &dev_srv_UUID);
																
																
    if (err_code != NRF_SUCCESS)
    {
        // Look for the short local name if it was not found as complete
        err_code = adv_report_parse(0x03, &adv_data, &dev_srv_UUID);
        if (err_code != NRF_SUCCESS)
        {
            // If we can't parse the data, then exit
            return;
        }
        else
        {
            found_name = true;
        }
    }
    else
    {
        found_name = true;
    }
    if (found_name)
    {
        if (strlen(m_target_periph_name) != 0)
        {
            uint16_t uuid = dev_srv_UUID.p_data[1]<<8 | dev_srv_UUID.p_data[0];
            
            if ( (uuid==TARGET_SRV_UUID) || (uuid==TARGET_SRV_UUID2))
            {
                uint8_t mng_mac_addr[] = {0x38, 0x3C, 0xAE, 0x55, 0xC2, 0x88};
                do_connect = memcmp((uint8_t *)p_ble_evt->evt.gap_evt.params.adv_report.peer_addr.addr, mng_mac_addr, 6);
                //NRF_LOG_PRINTF("0xFF10   \r\n");
                rssi_test = abs(p_gap_evt->params.adv_report.rssi); 
                if(do_connect != 0 && rssi_test < 50) {
                    do_connect = 1;
                    m_uuid = uuid;
                }
                else {
                    do_connect = 0;
                }
//                do_connect = My_Ble_Connect_Adv_Proc(rssi_test, (uint8_t *)p_ble_evt->evt.gap_evt.params.adv_report.peer_addr.addr);
            }
        }
    }

    if (do_connect)
    {
        do_connect = false;
        err_code = sd_ble_gap_connect(peer_addr, &m_scan_param, &m_connection_param);

        report_error = err_code;
        if (err_code != NRF_SUCCESS)
        {
            report_error = report_error;
        }
    }
}

#define LOG2                    NRF_LOG_PRINTF_DEBUG  /**< Debug logger macro that will be used in this file to do logging of important information over UART. */

#define TX_BUFFER_MASK2         0x07                  /**< TX Buffer mask, must be a mask of continuous zeroes, followed by continuous sequence of ones: 000...111. */
#define TX_BUFFER_SIZE2         (TX_BUFFER_MASK2 + 1)  /**< Size of send buffer, which is 1 higher than the mask. */

#define WRITE_MESSAGE_LENGTH2   BLE_CCCD_VALUE_LEN    /**< Length of the write message for CCCD. */
typedef enum
{
    READ_REQ,  /**< Type identifying that this tx_message is a read request. */
    WRITE_REQ  /**< Type identifying that this tx_message is a write request. */
} tx_request_t2;

typedef struct
{
    uint8_t                  gattc_value[WRITE_MESSAGE_LENGTH2];  /**< The message to write. */
    ble_gattc_write_params_t gattc_params;                       /**< GATTC parameters for this message. */
} write_params_t2;

typedef struct
{
    uint16_t     conn_handle;  /**< Connection handle to be used when transmitting this message. */
    tx_request_t2 type;         /**< Type of this message, i.e. read or write message. */
    union
    {
        uint16_t       read_handle;  /**< Read request message. */
        write_params_t2 write_req;    /**< Write request message. */
    } req;
} tx_message_t2;

static tx_message_t2 m_tx_buffer[TX_BUFFER_SIZE2];  /**< Transmit buffer for messages to be transmitted to the central. */
static uint32_t     m_tx_insert_index2 = 0;        /**< Current index in the transmit buffer where the next message should be inserted. */
static uint32_t     m_tx_index2 = 0;               /**< Current index in the transmit buffer from where the next message to be transmitted resides. */

static void tx_buffer_process(void)
{
    if (m_tx_index2 != m_tx_insert_index2)
    {
        uint32_t err_code;

        if (m_tx_buffer[m_tx_index2].type == READ_REQ)
        {
            err_code = sd_ble_gattc_read(m_tx_buffer[m_tx_index2].conn_handle,
                                         m_tx_buffer[m_tx_index2].req.read_handle,
                                         0);
        }
        else
        {
            err_code = sd_ble_gattc_write(m_tx_buffer[m_tx_index2].conn_handle,
                                          &m_tx_buffer[m_tx_index2].req.write_req.gattc_params);
        }
        if (err_code == NRF_SUCCESS)
        {
            LOG2("[LBS_C]: SD Read/Write API returns Success..\r\n");
            m_tx_index2++;
            m_tx_index2 &= TX_BUFFER_MASK2;
        }
        else
        {
            LOG2("[LBS_C]: SD Read/Write API returns error. This message sending will be "
                "attempted again..\r\n");
        }
    }
}

uint32_t tx_buffer_process2(void)
{
    if (m_tx_index2 != m_tx_insert_index2)
    {
        uint32_t err_code;

        if (m_tx_buffer[m_tx_index2].type == READ_REQ)
        {
            err_code = sd_ble_gattc_read(m_tx_buffer[m_tx_index2].conn_handle,
                                         m_tx_buffer[m_tx_index2].req.read_handle,
                                         0);
        }
        else
        {
            err_code = sd_ble_gattc_write(m_tx_buffer[m_tx_index2].conn_handle,
                                          &m_tx_buffer[m_tx_index2].req.write_req.gattc_params);
        }
        if (err_code == NRF_SUCCESS)
        {
            LOG2("[LBS_C]: SD Read/Write API returns Success..\r\n");
            m_tx_index2++;
            m_tx_index2 &= TX_BUFFER_MASK2;
        }
        else
        {
            LOG2("[LBS_C]: SD Read/Write API returns error. This message sending will be "
                "attempted again..\r\n");
					  __nop();
        }
				return err_code;
    }
}






static uint32_t cccd_configure(uint16_t conn_handle, uint16_t handle_cccd, bool enable)
{
    //LOG2("[LBS_C]: Configuring CCCD. CCCD Handle = %d, Connection Handle = %d\r\n",
    //    handle_cccd,conn_handle);

    tx_message_t2 * p_msg;
    uint16_t       cccd_val = enable ? BLE_GATT_HVX_NOTIFICATION : 0;

    p_msg              = &m_tx_buffer[m_tx_insert_index2++];
    m_tx_insert_index2 &= TX_BUFFER_MASK2;

    p_msg->req.write_req.gattc_params.handle   = handle_cccd;
    p_msg->req.write_req.gattc_params.len      = WRITE_MESSAGE_LENGTH2;
    p_msg->req.write_req.gattc_params.p_value  = p_msg->req.write_req.gattc_value;
    p_msg->req.write_req.gattc_params.offset   = 0;
    p_msg->req.write_req.gattc_params.write_op = BLE_GATT_OP_WRITE_REQ;
    p_msg->req.write_req.gattc_value[0]        = LSB_16(cccd_val);
    p_msg->req.write_req.gattc_value[1]        = MSB_16(cccd_val);
    p_msg->conn_handle                         = conn_handle;
    p_msg->type                                = WRITE_REQ;

    //tx_buffer_process();
	  uint32_t err_code;
	  err_code = tx_buffer_process2();
    return err_code;
}


void ble_lbs_led_status_send2(uint8_t conn_hadle,uint8_t cmd_niaoliang_l)
{
    //VERIFY_PARAM_NOT_NULL(p_ble_lbs_c);

//    if (p_ble_lbs_c->conn_handle == BLE_CONN_HANDLE_INVALID)
//    {
//        return NRF_ERROR_INVALID_STATE;
//    }
    uint8_t conn_hadle_t;
	  uint8_t cmd_niaoliang_t;
	  cmd_niaoliang_t = cmd_niaoliang_l;
    conn_hadle_t = conn_hadle;	
    ble_gattc_write_params_t niaoliang_params_t;
	  /*
    tx_message_t2 * p_msg;

    p_msg              = &m_tx_buffer[m_tx_insert_index2++];
    m_tx_insert_index2 &= TX_BUFFER_MASK2;

    //p_msg->req.write_req.gattc_params.handle   = p_ble_lbs_c->peer_lbs_db.led_handle;
	  p_msg->req.write_req.gattc_params.handle   = 0x0E;
	
    p_msg->req.write_req.gattc_params.len      = sizeof(0x55);
    p_msg->req.write_req.gattc_params.p_value  = p_msg->req.write_req.gattc_value;
    p_msg->req.write_req.gattc_params.offset   = 0;
    p_msg->req.write_req.gattc_params.write_op = BLE_GATT_OP_WRITE_CMD;
    p_msg->req.write_req.gattc_value[0]        = 0x55;
		
    //p_msg->conn_handle                         = p_ble_lbs_c->conn_handle;
		p_msg->conn_handle                         = 0;
		
    p_msg->type                                = WRITE_REQ;
    */
		uint8_t a= cmd_niaoliang_t;
		niaoliang_params_t.flags =
    niaoliang_params_t.handle = 0x0e; 
    niaoliang_params_t.len = 1;
    niaoliang_params_t.offset = 0;
    niaoliang_params_t.p_value = &a;
    niaoliang_params_t.write_op = BLE_GATT_OP_WRITE_CMD;
		
    sd_ble_gattc_write(conn_hadle_t,&niaoliang_params_t);
    //tx_buffer_process();
}


/**@brief Function for handling BLE Stack events concerning central applications.
 *
 * @details This function keeps the connection handles of central applications up-to-date. It
 *          parses scanning reports, initiating a connection attempt to peripherals when a
 *          target UUID is found, and manages connection parameter update requests. Additionally,
 *          it updates the status of LEDs used to report central applications activity.
 *
 * @note Since this function updates connection handles, @ref BLE_GAP_EVT_DISCONNECTED events
 *       should be dispatched to the target application before invoking this function.
 *
 * @param[in] p_ble_evt  Bluetooth stack event.
 */


uint8_t erssi;
ret_code_t err_code99;
uint8_t cccd_enable_cnt=0;
uint8_t disconnect_cnt=0;
uint8_t evt_centrl_link_cnt = 0;
uint8_t adv_cnt=0;
ble_gap_conn_params_t update_param;
uint32_t m_timeout_src=0;
extern MY_BLE_CONNECT_CB_ST my_st_ble_connect_cb;
static void on_ble_evt(const ble_evt_t * const p_ble_evt)
{
    // For readability.
    adv_cnt++;
    const ble_gap_evt_t * const p_gap_evt = &p_ble_evt->evt.gap_evt;
    switch (p_ble_evt->header.evt_id)
    {
        // Upon connection, check which peripheral has connected, initiate DB
        // discovery, update LEDs status and resume scanning if necessary.
        case BLE_GAP_EVT_CONNECTED:
        {
            uint32_t err_code;
            uint32_t central_link_cnt; // Number of central links.

            APP_ERROR_CHECK_BOOL(p_gap_evt->conn_handle < TOTAL_LINK_COUNT);
           
            err_code = ble_lbs_c_handles_assign(&m_ble_lbs_c[p_gap_evt->conn_handle], 
                                                p_gap_evt->conn_handle, 
                                                NULL);
            APP_ERROR_CHECK(err_code);

//            err_code = ble_db_discovery_start(&m_ble_db_discovery[p_gap_evt->conn_handle],
//                                              p_gap_evt->conn_handle);
//            if (err_code != NRF_ERROR_BUSY)
//            {
//                APP_ERROR_CHECK(err_code);
//            }
            
            My_Ble_Connect_Connected_Proc(p_ble_evt);

            //enable CCCD
            if(m_uuid == 0xFFF0) {
                err_code = cccd_configure(p_gap_evt->conn_handle,TARGET_CCCD_handle,true);
                APP_ERROR_CHECK(err_code);
            }
            else if(m_uuid == 0xFFF1) {
                err_code = cccd_configure(p_gap_evt->conn_handle,TARGET_CCCD_handle2,true);
                APP_ERROR_CHECK(err_code);
            }
            __nop();
        } break; // BLE_GAP_EVT_CONNECTED

        // Upon disconnection, reset the connection handle of the peer which disconnected, update
        // the LEDs status and start scanning again.
        case BLE_GAP_EVT_DISCONNECTED:
        {
            disconnect_cnt++;
            mcccd_handle = p_gap_evt->conn_handle;
            My_Ble_Connect_Disconnected_Proc(p_ble_evt);
            // Start scanning
            scan_start();

        } break; // BLE_GAP_EVT_DISCONNECTED

        case BLE_GAP_EVT_ADV_REPORT:
            on_adv_report(p_ble_evt);
        break; // BLE_GAP_ADV_REPORT

        case BLE_GAP_EVT_TIMEOUT:
        {

            m_timeout_src = p_gap_evt->params.timeout.src;
            // We have not specified a timeout for scanning, so only connection attemps can timeout.
            if (p_gap_evt->params.timeout.src == BLE_GAP_TIMEOUT_SRC_CONN)
            {
                APPL_LOG("[APPL]: Connection Request timed out.\r\n");
            }
						
//						scan_start();
        } break; // BLE_GAP_EVT_TIMEOUT

        case BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST:
        {
            // Accept parameters requested by peer.
            //ret_code_t err_code;
//            err_code99 = sd_ble_gap_conn_param_update(p_gap_evt->conn_handle,
//                                        &p_gap_evt->params.conn_param_update_request.conn_params);
//            mcccd_handle = p_gap_evt->conn_handle;
//            update_param = p_gap_evt->params.conn_param_update_request.conn_params;
//            ble_conn_params_change_conn_params(&update_param);
//            APP_ERROR_CHECK(err_code99);
        } break; // BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST
        case BLE_GAP_EVT_CONN_PARAM_UPDATE:
        {  
//            on_conn_params_update(p_ble_evt);
            break;
        }
        case BLE_GAP_EVT_RSSI_CHANGED:
        {
//            // Accept parameters requested by peer.
//            //ret_code_t err_code;
//            sd_ble_gap_rssi_start(0,0x00, 0x00);
//            sd_ble_gap_rssi_get(0, &erssi);
//					  erssi = p_gap_evt->params.rssi_changed.rssi;
//					  __nop();
//            //APP_ERROR_CHECK(err_code);  
        } break; // BLE_GAP_EVT_RSSI_CHANGED
				

        default:
            // No implementation needed.
            break;
    }
}


/**@brief Function for dispatching a BLE stack event to all modules with a BLE stack event handler.
 *
 * @details This function is called from the scheduler in the main loop after a BLE stack event has
 * been received.
 *
 * @param[in] p_ble_evt  Bluetooth stack event.
 */
ble_evt_t  mmble_evt;
uint16_t mconn_handle;
static void ble_evt_dispatch(ble_evt_t * p_ble_evt)
{
    uint16_t conn_handle;
    conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
    mconn_handle = conn_handle;
//        ble_db_discovery_on_ble_evt(&m_ble_db_discovery[conn_handle], p_ble_evt);
    if(p_ble_evt->header.evt_id != 0x1D)
        mmble_evt.header.evt_id = p_ble_evt->header.evt_id;
    on_ble_evt(p_ble_evt);
    ble_conn_state_on_ble_evt(p_ble_evt);
        ble_lbs_c_on_ble_evt(&m_ble_lbs_c[conn_handle], p_ble_evt);

    // Make sure taht an invalid connection handle are not passed since
    // our array of modules is bound to TOTAL_LINK_COUNT.
    if (conn_handle < TOTAL_LINK_COUNT)
    {
//			  scan_start();
    }
}


static void sys_evt_dispatch(uint32_t sys_evt)
{
    pstorage_sys_event_handler(sys_evt);
}


/**@brief LED Button collector initialization.
 */
static void lbs_c_init(void)
{
    uint32_t         err_code;
    ble_lbs_c_init_t lbs_c_init_obj;

    lbs_c_init_obj.evt_handler = lbs_c_evt_handler;

    for(m_ble_lbs_c_count = 0; m_ble_lbs_c_count < TOTAL_LINK_COUNT; m_ble_lbs_c_count++)
    {
        err_code = ble_lbs_c_init(&m_ble_lbs_c[m_ble_lbs_c_count], &lbs_c_init_obj);
        APP_ERROR_CHECK(err_code);
    }
    m_ble_lbs_c_count = 0;
}


/**@brief Function for initializing the BLE stack.
 *
 * @details Initializes the SoftDevice and the BLE event interrupts.
 */
static void ble_stack_init(void)
{
    ret_code_t err_code;
    
    nrf_clock_lf_cfg_t clock_lf_cfg = NRF_CLOCK_LFCLKSRC;
    
    // Initialize the SoftDevice handler module.
    SOFTDEVICE_HANDLER_INIT(&clock_lf_cfg, NULL);
    
    ble_enable_params_t ble_enable_params;
    err_code = softdevice_enable_get_default_config(CENTRAL_LINK_COUNT,
                                                    PERIPHERAL_LINK_COUNT,
                                                    &ble_enable_params);
    APP_ERROR_CHECK(err_code);
    
    // Stack checks first if there are still entries in the table before checking if a vendor
    // specific UUID is already in the table thus to be able to call sd_ble_uuid_vs_add several
    // times with the same entry, vs_uuid_count has to be 1 bigger than what is actually needed.
//    ble_enable_params.common_enable_params.vs_uuid_count = 2;
    
    // Check the ram settings against the used number of links
    CHECK_RAM_START_ADDR(CENTRAL_LINK_COUNT,PERIPHERAL_LINK_COUNT);
    
    // Enable BLE stack.
    err_code = softdevice_enable(&ble_enable_params);
    APP_ERROR_CHECK(err_code);

    // Register with the SoftDevice handler module for BLE events.
    err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
    APP_ERROR_CHECK(err_code);
    
    // Register with the SoftDevice handler module for BLE events.
    err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);
    APP_ERROR_CHECK(err_code);
}


/**@brief Function to write to the LED characterestic of all connected clients.
 *
 * @details Based on if the button is pressed or released, we write a high or low LED status to
 *          the server.
 *
 * @param[in] button_action The button action (press/release).
 *            Determines if the LEDs of the servers will be ON or OFF.
 *
 * @return NRF_SUCCESS on success, else the error code from ble_lbs_led_status_send.
 */
static uint32_t led_status_send_to_all(uint8_t button_action)
{
    uint32_t err_code;

    for (uint32_t i = 0; i< CENTRAL_LINK_COUNT; i++)
    {
        err_code = ble_lbs_led_status_send(&m_ble_lbs_c[i], button_action);
        if (err_code != NRF_SUCCESS &&
            err_code != BLE_ERROR_INVALID_CONN_HANDLE &&
            err_code != NRF_ERROR_INVALID_STATE)
        {
            return err_code;
        }
    }
        return NRF_SUCCESS;
}


/**@brief Function for handling events from the button handler module.
 *
 * @param[in] pin_no        The pin that the event applies to.
 * @param[in] button_action The button action (press/release).
 */
static void button_event_handler(uint8_t pin_no, uint8_t button_action)
{
    uint32_t err_code;

    switch (pin_no)
    {
        case LEDBUTTON_BUTTON_PIN:
            if (err_code == NRF_SUCCESS)
            {
                My_Ble_Disconnect_All();
            }
            break;

        default:
            APP_ERROR_HANDLER(pin_no);
            break;
    }
}


/**@brief Function for initializing the button handler module.
 */
static void buttons_init(void)
{
    uint32_t err_code;

   //The array must be static because a pointer to it will be saved in the button handler module.
    static app_button_cfg_t buttons[] =
    {
        {LEDBUTTON_BUTTON_PIN, false, BUTTON_PULL, button_event_handler}
    };

    err_code = app_button_init(buttons, sizeof(buttons) / sizeof(buttons[0]),
                               BUTTON_DETECTION_DELAY);
    app_button_enable();
    APP_ERROR_CHECK(err_code);
}


/**@brief Function for handling database discovery events.
 *
 * @details This function is callback function to handle events from the database discovery module.
 *          Depending on the UUIDs that are discovered, this function should forward the events
 *          to their respective services.
 *
 * @param[in] p_event  Pointer to the database discovery event.
 */
static void db_disc_handler(ble_db_discovery_evt_t * p_evt)
{
    NRF_LOG_PRINTF("[APP]: call to ble_lbs_on_db_disc_evt for instance %d and link 0x%x!\r\n", 
                    p_evt->conn_handle,
                    p_evt->conn_handle);
    ble_lbs_on_db_disc_evt(&m_ble_lbs_c[p_evt->conn_handle], p_evt);
}


/** @brief Database discovery initialization.
 */
static void db_discovery_init(void)
{
    ret_code_t err_code = ble_db_discovery_init(db_disc_handler);
    APP_ERROR_CHECK(err_code);
}



/** @brief Function to sleep until a BLE event is received by the application.
 */
static void power_manage(void)
{
    ret_code_t err_code = sd_app_evt_wait();
    APP_ERROR_CHECK(err_code);
}




void pa_lna_init(uint32_t gpio_pa_pin, uint32_t gpio_lna_pin)
{
    ret_code_t err_code;  
    
	  static const uint32_t gpio_toggle_ch = 0;
	  static const uint32_t ppi_set_ch = 0;
	  static const uint32_t ppi_clr_ch = 1;

  	// Configure SoftDevice PA/LNA assist
    ble_opt_t opt;
    memset(&opt, 0, sizeof(ble_opt_t));
    // Common PA/LNA config
    opt.common_opt.pa_lna.gpiote_ch_id  = gpio_toggle_ch;        // GPIOTE channel
    opt.common_opt.pa_lna.ppi_ch_id_clr = ppi_clr_ch;            // PPI channel for pin clearing
    opt.common_opt.pa_lna.ppi_ch_id_set = ppi_set_ch;            // PPI channel for pin setting
    // PA config
    opt.common_opt.pa_lna.pa_cfg.active_high = 1;                // Set the pin to be active high
    opt.common_opt.pa_lna.pa_cfg.enable      = 1;                // Enable toggling
    opt.common_opt.pa_lna.pa_cfg.gpio_pin    = gpio_pa_pin;      // The GPIO pin to toggle

    // LNA config
    opt.common_opt.pa_lna.lna_cfg.active_high  = 1;              // Set the pin to be active high
    opt.common_opt.pa_lna.lna_cfg.enable       = 1;              // Enable toggling
    opt.common_opt.pa_lna.lna_cfg.gpio_pin     = gpio_lna_pin;   // The GPIO pin to toggle

    err_code = sd_ble_opt_set(BLE_COMMON_OPT_PA_LNA, &opt);
    APP_ERROR_CHECK(err_code);

}


extern nrf_drv_wdt_channel_id m_channel_id;
void wdt_event_handler(void)
{
	  __nop();
    
    //NOTE: The max amount of time we can spend in WDT interrupt is two cycles of 32768[Hz] clock - after that, reset occurs
}
void init_WDT()
{
	uint32_t err_code0;
  //Configure WDT.
  nrf_drv_wdt_config_t config = NRF_DRV_WDT_DEAFULT_CONFIG;
  err_code0 = nrf_drv_wdt_init(&config, wdt_event_handler);
  APP_ERROR_CHECK(err_code0);
  err_code0 = nrf_drv_wdt_channel_alloc(&m_channel_id);
  APP_ERROR_CHECK(err_code0);
  nrf_drv_wdt_enable();
}


void System_Start_Signal(void)
{
    nrf_gpio_pin_clear(7);
    nrf_gpio_pin_set(9);
    delay_ms(10000);
    nrf_gpio_pin_set(7);
    nrf_gpio_pin_clear(9);
}

void HardFault_Handler(void)
{
    while(1);
}

#define MODE_TEMP_TO_RES_NORMAL     1
#define MODE_TEMP_TO_RES_TEST       2
#define MODE_TEMP_PATCH_TEST        3
#define BLE_WORK_MODE               MODE_TEMP_PATCH_TEST
int main(void)
{
    uint8_t i=1;
    uint8_t key_value=0;
    uint32_t central_link_cnt; // Number of central links.
    
    APP_TIMER_INIT(APP_TIMER_PRESCALER, APP_TIMER_OP_QUEUE_SIZE, NULL);
//    init_WDT();
//	
//    nrf_wdt_int_enable(NRF_WDT_INT_TIMEOUT_MASK);
//    nrf_drv_wdt_channel_feed(m_channel_id);
	
    ble_stack_init();
    
    simple_uart_config(RTS_PIN_NUMBER, TX_PIN_NUMBER, CTS_PIN_NUMBER, RX_PIN_NUMBER, HWFC);
    uart_exit();
    
    buttons_init();
    LED_CONFIGURE(7);
//    BUTTON_CONFIGURE(8);
    TempToRes_Init();
    My_Ble_Connect_Init(32767);
    Beep_Init();
    System_Start_Signal();
    
    db_discovery_init();
    lbs_c_init();
    pa_lna_init(20,19);
    scan_start();
    
    for (;;)
    {	
        central_link_cnt = ble_conn_state_n_centrals();
        
        if(central_link_cnt&&i)
        {
            i=0;
            nrf_gpio_pin_clear(7);
        }
        else if(central_link_cnt == 0)
        {
            i=1;
            nrf_gpio_pin_set(7);
        }

#if BLE_WORK_MODE == MODE_TEMP_TO_RES_NORMAL
        TemperatureToResProc();
#elif BLE_WORK_MODE == MODE_TEMP_PATCH_TEST
        TemperatureUploadTest();
#elif BLE_WORK_MODE == MODE_TEMP_TO_RES_TEST
        TemperatureToResTest();
#endif
        power_manage();
    }
}
